ജാവാസ്ക്രിപ്റ്റ് ടെസ്റ്റിംഗിൽ പ്രാവീണ്യം നേടാം: മികച്ച ആപ്ലിക്കേഷനുകൾക്കായി ജെസ്റ്റ് കോൺഫിഗറേഷനും കസ്റ്റം മാച്ചറുകളും

വേഗത്തിൽ മാറിക്കൊണ്ടിരിക്കുന്ന ഇന്നത്തെ സോഫ്റ്റ്‌വെയർ ലോകത്ത്, കരുത്തുറ്റതും വിശ്വസനീയവുമായ ആപ്ലിക്കേഷനുകൾക്ക് വലിയ പ്രാധാന്യമുണ്ട്. അത്തരം ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന്റെ അടിസ്ഥാന ശിലയാണ് കാര്യക്ഷമമായ ടെസ്റ്റിംഗ്. ഫ്രണ്ട്-എൻഡ്, ബാക്ക്-എൻഡ് ഡെവലപ്‌മെന്റുകളിൽ ഒരുപോലെ പ്രാമുഖ്യമുള്ള ഭാഷയായ ജാവാസ്ക്രിപ്റ്റിന്, ശക്തവും വൈവിധ്യപൂർണ്ണവുമായ ഒരു ടെസ്റ്റിംഗ് ഫ്രെയിംവർക്ക് ആവശ്യമാണ്. ഫേസ്ബുക്ക് വികസിപ്പിച്ച ജെസ്റ്റ്, ഒരു മുൻനിര ഫ്രെയിംവർക്കായി ഉയർന്നുവന്നിരിക്കുന്നു. സീറോ-കോൺഫിഗറേഷൻ സെറ്റപ്പ്, ശക്തമായ മോക്കിംഗ് കഴിവുകൾ, മികച്ച പ്രകടനം എന്നിവ ഇത് വാഗ്ദാനം ചെയ്യുന്നു. ഈ സമഗ്രമായ ഗൈഡ് ജെസ്റ്റ് കോൺഫിഗറേഷന്റെ സങ്കീർണ്ണതകളിലേക്കും കസ്റ്റം മാച്ചറുകളുടെ നിർമ്മാണത്തിലേക്കും ആഴത്തിൽ ഇറങ്ങിച്ചെല്ലുന്നു, നിങ്ങളുടെ സ്ഥാനം എവിടെയായാലും പ്രോജക്റ്റിന്റെ വലുപ്പം എന്തുതന്നെയായാലും, ജാവാസ്ക്രിപ്റ്റ് കോഡിന്റെ ഗുണമേന്മയും വിശ്വാസ്യതയും ഉറപ്പാക്കുന്ന, കൂടുതൽ വ്യക്തവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ ടെസ്റ്റുകൾ എഴുതാൻ ഇത് നിങ്ങളെ സഹായിക്കും.

എന്തുകൊണ്ട് ജെസ്റ്റ്? ജാവാസ്ക്രിപ്റ്റ് ടെസ്റ്റിംഗിനുള്ള ഒരു ആഗോള നിലവാരം

കോൺഫിഗറേഷനിലേക്കും കസ്റ്റം മാച്ചറുകളിലേക്കും കടക്കുന്നതിന് മുമ്പ്, ലോകമെമ്പാടുമുള്ള ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്പർമാർക്ക് ജെസ്റ്റ് ഒരു പ്രധാന ഫ്രെയിംവർക്കായി മാറിയത് എന്തുകൊണ്ടാണെന്ന് നമുക്ക് മനസ്സിലാക്കാം:

• സീറോ കോൺഫിഗറേഷൻ: ജെസ്റ്റ് വളരെ എളുപ്പത്തിൽ സജ്ജീകരിക്കാൻ സാധിക്കും, ഇത് കുറഞ്ഞ കോൺഫിഗറേഷനിൽ ടെസ്റ്റുകൾ എഴുതാൻ നിങ്ങളെ സഹായിക്കുന്നു. ടെസ്റ്റ്-ഡ്രൈവൻ ഡെവലപ്‌മെന്റ് (TDD) അല്ലെങ്കിൽ ബിഹേവിയർ-ഡ്രൈവൻ ഡെവലപ്‌മെന്റ് (BDD) രീതികൾ സ്വീകരിക്കുന്ന ടീമുകൾക്ക് ഇത് വളരെ പ്രയോജനകരമാണ്.
• വേഗതയേറിയതും കാര്യക്ഷമവും: ജെസ്റ്റിന്റെ പാരലൽ ടെസ്റ്റ് എക്സിക്യൂഷനും കാഷിംഗ് മെക്കാനിസവും വേഗത്തിലുള്ള ടെസ്റ്റ് സൈക്കിളുകൾക്ക് സഹായിക്കുന്നു, ഇത് ഡെവലപ്‌മെന്റ് സമയത്ത് വേഗത്തിൽ ഫീഡ്‌ബാക്ക് നൽകുന്നു.
• ബിൽറ്റ്-ഇൻ മോക്കിംഗ്: ജെസ്റ്റ് ശക്തമായ മോക്കിംഗ് കഴിവുകൾ നൽകുന്നു, ഇത് കോഡിന്റെ യൂണിറ്റുകൾ വേർതിരിക്കാനും കാര്യക്ഷമമായ യൂണിറ്റ് ടെസ്റ്റിംഗിനായി ഡിപൻഡൻസികളെ സിമുലേറ്റ് ചെയ്യാനും നിങ്ങളെ സഹായിക്കുന്നു.
• സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റിംഗ്: ജെസ്റ്റിന്റെ സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റിംഗ് ഫീച്ചർ യുഐ ഘടകങ്ങളും ഡാറ്റാ ഘടനകളും പരിശോധിക്കുന്ന പ്രക്രിയ ലളിതമാക്കുന്നു, അപ്രതീക്ഷിത മാറ്റങ്ങൾ എളുപ്പത്തിൽ കണ്ടെത്താൻ ഇത് നിങ്ങളെ സഹായിക്കുന്നു.
• മികച്ച ഡോക്യുമെന്റേഷനും കമ്മ്യൂണിറ്റി പിന്തുണയും: ജെസ്റ്റിന് സമഗ്രമായ ഡോക്യുമെന്റേഷനും സജീവമായ ഒരു കമ്മ്യൂണിറ്റിയുമുണ്ട്, ഇത് ഉത്തരങ്ങൾ കണ്ടെത്താനും ആവശ്യമുള്ളപ്പോൾ സഹായം നേടാനും എളുപ്പമാക്കുന്നു. ലോകമെമ്പാടുമുള്ള വിവിധ സാഹചര്യങ്ങളിൽ പ്രവർത്തിക്കുന്ന ഡെവലപ്പർമാർക്ക് ഇത് വളരെ പ്രധാനമാണ്.
• വ്യാപകമായ സ്വീകാര്യത: സ്റ്റാർട്ടപ്പുകൾ മുതൽ വലിയ സംരംഭങ്ങൾ വരെ ലോകമെമ്പാടുമുള്ള കമ്പനികൾ അവരുടെ ജാവാസ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകൾ ടെസ്റ്റ് ചെയ്യാൻ ജെസ്റ്റിനെ ആശ്രയിക്കുന്നു. ഈ വ്യാപകമായ സ്വീകാര്യത തുടർച്ചയായ മെച്ചപ്പെടുത്തലും ധാരാളം വിഭവങ്ങളും ഉറപ്പാക്കുന്നു.

ജെസ്റ്റ് കോൺഫിഗർ ചെയ്യുന്നു: നിങ്ങളുടെ ടെസ്റ്റിംഗ് എൻവയോൺമെന്റ് ഇഷ്ടാനുസൃതമാക്കാം

ജെസ്റ്റ് ഒരു സീറോ-കോൺഫിഗറേഷൻ അനുഭവം വാഗ്ദാനം ചെയ്യുന്നുണ്ടെങ്കിലും, നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ പ്രത്യേക ആവശ്യങ്ങൾക്കനുസരിച്ച് ഇത് കസ്റ്റമൈസ് ചെയ്യേണ്ടത് പലപ്പോഴും ആവശ്യമാണ്. ജെസ്റ്റ് കോൺഫിഗർ ചെയ്യുന്നതിനുള്ള പ്രധാന മാർഗ്ഗം നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ റൂട്ടിലുള്ള `jest.config.js` ഫയലാണ് (അല്ലെങ്കിൽ ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുകയാണെങ്കിൽ `jest.config.ts`). ചില പ്രധാന കോൺഫിഗറേഷൻ ഓപ്ഷനുകൾ നമുക്ക് പരിശോധിക്കാം:

`transform`: നിങ്ങളുടെ കോഡ് ട്രാൻസ്പൈൽ ചെയ്യുന്നു

`transform` ഓപ്ഷൻ, ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് ജെസ്റ്റ് നിങ്ങളുടെ സോഴ്സ് കോഡിനെ എങ്ങനെ പരിവർത്തനം ചെയ്യണമെന്ന് വ്യക്തമാക്കുന്നു. ആധുനിക ജാവാസ്ക്രിപ്റ്റ് ഫീച്ചറുകൾ, JSX, ടൈപ്പ്സ്ക്രിപ്റ്റ്, അല്ലെങ്കിൽ മറ്റേതെങ്കിലും നോൺ-സ്റ്റാൻഡേർഡ് സിന്റാക്സ് കൈകാര്യം ചെയ്യുന്നതിന് ഇത് അത്യാവശ്യമാണ്. സാധാരണയായി, ട്രാൻസ്പിലേഷനായി നിങ്ങൾ ബാബേൽ (Babel) ഉപയോഗിക്കും.

ഉദാഹരണം (`jest.config.js`):

module.exports = {
  transform: {
    '^.+\\.js$': 'babel-jest',
    '^.+\\.jsx$': 'babel-jest',
    '^.+\\.ts?$': 'ts-jest',
  },
};

ഈ കോൺഫിഗറേഷൻ `.js`, `.jsx` ഫയലുകൾ ട്രാൻസ്ഫോം ചെയ്യാൻ `babel-jest`-ഉം, `.ts` ഫയലുകൾ ട്രാൻസ്ഫോം ചെയ്യാൻ `ts-jest`-ഉം ഉപയോഗിക്കാൻ ജെസ്റ്റിനോട് പറയുന്നു. ആവശ്യമായ പാക്കേജുകൾ (`npm install --save-dev babel-jest @babel/core @babel/preset-env ts-jest typescript`) ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. ആഗോള ടീമുകൾക്കായി, എല്ലാ പ്രദേശങ്ങളിലും ഉപയോഗിക്കുന്ന അനുയോജ്യമായ ECMAScript പതിപ്പുകളെ പിന്തുണയ്ക്കുന്ന തരത്തിൽ ബാബേൽ കോൺഫിഗർ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.

`testEnvironment`: എക്സിക്യൂഷൻ കോൺടെക്സ്റ്റ് സിമുലേറ്റ് ചെയ്യുന്നു

`testEnvironment` ഓപ്ഷൻ നിങ്ങളുടെ ടെസ്റ്റുകൾ ഏത് എൻവയോൺമെന്റിൽ പ്രവർത്തിക്കണമെന്ന് വ്യക്തമാക്കുന്നു. `node` (ബാക്ക്-എൻഡ് കോഡിനായി), `jsdom` (DOM-മായി സംവദിക്കുന്ന ഫ്രണ്ട്-എൻഡ് കോഡിനായി) എന്നിവ സാധാരണ ഓപ്ഷനുകളിൽ ഉൾപ്പെടുന്നു.

ഉദാഹരണം (`jest.config.js`):

module.exports = {
  testEnvironment: 'jsdom',
};

`jsdom` ഉപയോഗിക്കുന്നത് ഒരു ബ്രൗസർ എൻവയോൺമെന്റ് സിമുലേറ്റ് ചെയ്യുന്നു, ഇത് റിയാക്റ്റ് ഘടകങ്ങളോ അല്ലെങ്കിൽ DOM-നെ ആശ്രയിക്കുന്ന മറ്റ് കോഡുകളോ ടെസ്റ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. Node.js അടിസ്ഥാനമാക്കിയുള്ള ആപ്ലിക്കേഷനുകൾക്കോ ബാക്ക്-എൻഡ് ടെസ്റ്റിംഗിനോ `node` ആണ് അഭികാമ്യം. അന്താരാഷ്ട്രവൽക്കരിച്ച ആപ്ലിക്കേഷനുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, നിങ്ങളുടെ ടാർഗെറ്റ് പ്രേക്ഷകർക്ക് പ്രസക്തമായ ലൊക്കേൽ ക്രമീകരണങ്ങൾ `testEnvironment` ശരിയായി സിമുലേറ്റ് ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുക.

`moduleNameMapper`: മൊഡ്യൂൾ ഇംപോർട്ടുകൾ പരിഹരിക്കുന്നു

`moduleNameMapper` ഓപ്ഷൻ മൊഡ്യൂൾ നാമങ്ങളെ വ്യത്യസ്ത പാതകളിലേക്ക് മാപ്പ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് മൊഡ്യൂളുകൾ മോക്ക് ചെയ്യുന്നതിനും, അബ്സൊല്യൂട്ട് ഇംപോർട്ടുകൾ കൈകാര്യം ചെയ്യുന്നതിനും, അല്ലെങ്കിൽ പാത്ത് അലിയാസുകൾ പരിഹരിക്കുന്നതിനും ഉപയോഗപ്രദമാണ്.

ഉദാഹരണം (`jest.config.js`):

module.exports = {
  moduleNameMapper: {
    '^@components/(.*)$': '/src/components/$1',
  },
};

ഈ കോൺഫിഗറേഷൻ `@components/` എന്ന് തുടങ്ങുന്ന ഇംപോർട്ടുകളെ `src/components` ഡയറക്ടറിയിലേക്ക് മാപ്പ് ചെയ്യുന്നു. ഇത് ഇംപോർട്ടുകൾ ലളിതമാക്കുകയും കോഡിന്റെ വായനാക്ഷമത മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. ആഗോള പ്രോജക്റ്റുകൾക്ക്, അബ്സൊല്യൂട്ട് ഇംപോർട്ടുകൾ ഉപയോഗിക്കുന്നത് വ്യത്യസ്ത ഡിപ്ലോയ്മെന്റ് എൻവയോൺമെന്റുകളിലും ടീം ഘടനകളിലും പരിപാലനം എളുപ്പമാക്കും.

`testMatch`: ടെസ്റ്റ് ഫയലുകൾ വ്യക്തമാക്കുന്നു

`testMatch` ഓപ്ഷൻ ടെസ്റ്റ് ഫയലുകൾ കണ്ടെത്താൻ ഉപയോഗിക്കുന്ന പാറ്റേണുകൾ നിർവചിക്കുന്നു. ഡിഫോൾട്ടായി, `.test.js`, `.spec.js`, `.test.jsx`, `.spec.jsx`, `.test.ts`, അല്ലെങ്കിൽ `.spec.ts` എന്നിങ്ങനെയുള്ള ഫയലുകൾക്കായാണ് ജെസ്റ്റ് തിരയുന്നത്. നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ പേരിടൽ രീതികളുമായി പൊരുത്തപ്പെടുന്നതിന് നിങ്ങൾക്ക് ഇത് ഇഷ്ടാനുസൃതമാക്കാം.

ഉദാഹരണം (`jest.config.js`):

module.exports = {
  testMatch: ['/src/**/*.test.js'],
};

ഈ കോൺഫിഗറേഷൻ `src` ഡയറക്ടറിയിലും അതിന്റെ ഉപഡയറക്ടറികളിലും `.test.js` എന്ന് അവസാനിക്കുന്ന ടെസ്റ്റ് ഫയലുകൾക്കായി തിരയാൻ ജെസ്റ്റിനോട് പറയുന്നു. ടെസ്റ്റ് ഫയലുകൾക്കായി സ്ഥിരതയുള്ള പേരിടൽ രീതികൾ പരിപാലനത്തിന് നിർണായകമാണ്, പ്രത്യേകിച്ച് വലുതും വിതരണം ചെയ്യപ്പെട്ടതുമായ ടീമുകളിൽ.

`coverageDirectory`: കവറേജ് ഔട്ട്പുട്ട് വ്യക്തമാക്കുന്നു

`coverageDirectory` ഓപ്ഷൻ ജെസ്റ്റ് കോഡ് കവറേജ് റിപ്പോർട്ടുകൾ എവിടെ ഔട്ട്പുട്ട് ചെയ്യണമെന്ന് വ്യക്തമാക്കുന്ന ഡയറക്ടറിയെ സൂചിപ്പിക്കുന്നു. നിങ്ങളുടെ ടെസ്റ്റുകൾ ആപ്ലിക്കേഷന്റെ എല്ലാ പ്രധാന ഭാഗങ്ങളും കവർ ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുന്നതിനും അധിക ടെസ്റ്റിംഗ് ആവശ്യമായേക്കാവുന്ന മേഖലകൾ തിരിച്ചറിയുന്നതിനും കോഡ് കവറേജ് വിശകലനം അത്യാവശ്യമാണ്.

ഉദാഹരണം (`jest.config.js`):

module.exports = {
  coverageDirectory: 'coverage',
};

ഈ കോൺഫിഗറേഷൻ `coverage` എന്ന് പേരുള്ള ഒരു ഡയറക്ടറിയിലേക്ക് കവറേജ് റിപ്പോർട്ടുകൾ ഔട്ട്പുട്ട് ചെയ്യാൻ ജെസ്റ്റിനെ നിർദ്ദേശിക്കുന്നു. കോഡ് കവറേജ് റിപ്പോർട്ടുകൾ പതിവായി അവലോകനം ചെയ്യുന്നത് കോഡ്ബേസിന്റെ മൊത്തത്തിലുള്ള ഗുണനിലവാരം മെച്ചപ്പെടുത്തുന്നതിനും ടെസ്റ്റുകൾ നിർണായകമായ പ്രവർത്തനങ്ങളെ വേണ്ടത്ര കവർ ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുന്നതിനും സഹായിക്കുന്നു. വിവിധ പ്രദേശങ്ങളിലുടനീളം സ്ഥിരമായ പ്രവർത്തനക്ഷമതയും ഡാറ്റാ മൂല്യനിർണ്ണയവും ഉറപ്പാക്കാൻ അന്താരാഷ്ട്ര ആപ്ലിക്കേഷനുകൾക്ക് ഇത് വളരെ പ്രധാനമാണ്.

`setupFilesAfterEnv`: സെറ്റപ്പ് കോഡ് പ്രവർത്തിപ്പിക്കുന്നു

`setupFilesAfterEnv` ഓപ്ഷൻ, ടെസ്റ്റിംഗ് എൻവയോൺമെന്റ് സജ്ജീകരിച്ചതിന് ശേഷം പ്രവർത്തിപ്പിക്കേണ്ട ഫയലുകളുടെ ഒരു നിരയെ വ്യക്തമാക്കുന്നു. മോക്കുകൾ സജ്ജീകരിക്കുന്നതിനും, ഗ്ലോബൽ വേരിയബിളുകൾ കോൺഫിഗർ ചെയ്യുന്നതിനും, അല്ലെങ്കിൽ കസ്റ്റം മാച്ചറുകൾ ചേർക്കുന്നതിനും ഇത് ഉപയോഗപ്രദമാണ്. കസ്റ്റം മാച്ചറുകൾ നിർവചിക്കുമ്പോൾ ഉപയോഗിക്കേണ്ട എൻട്രി പോയിന്റാണിത്.

ഉദാഹരണം (`jest.config.js`):

module.exports = {
  setupFilesAfterEnv: ['/src/setupTests.js'],
};

എൻവയോൺമെന്റ് സജ്ജീകരിച്ചതിന് ശേഷം `src/setupTests.js`-ലെ കോഡ് പ്രവർത്തിപ്പിക്കാൻ ഇത് ജെസ്റ്റിനോട് പറയുന്നു. അടുത്ത വിഭാഗത്തിൽ നമ്മൾ ചർച്ച ചെയ്യുന്ന നിങ്ങളുടെ കസ്റ്റം മാച്ചറുകൾ ഇവിടെയാണ് നിങ്ങൾ രജിസ്റ്റർ ചെയ്യേണ്ടത്.

മറ്റ് ഉപയോഗപ്രദമായ കോൺഫിഗറേഷൻ ഓപ്ഷനുകൾ

• `verbose`: കൺസോളിൽ വിശദമായ ടെസ്റ്റ് ഫലങ്ങൾ പ്രദർശിപ്പിക്കണമോ എന്ന് വ്യക്തമാക്കുന്നു.
• `collectCoverageFrom`: കോഡ് കവറേജ് റിപ്പോർട്ടുകളിൽ ഏതൊക്കെ ഫയലുകൾ ഉൾപ്പെടുത്തണമെന്ന് നിർവചിക്കുന്നു.
• `moduleDirectories`: മൊഡ്യൂളുകൾക്കായി തിരയാൻ അധിക ഡയറക്ടറികൾ വ്യക്തമാക്കുന്നു.
• `clearMocks`: ടെസ്റ്റ് എക്സിക്യൂഷനുകൾക്കിടയിൽ മോക്കുകളെ സ്വയമേവ ക്ലിയർ ചെയ്യുന്നു.
• `resetMocks`: ഓരോ ടെസ്റ്റ് എക്സിക്യൂഷനും മുമ്പായി മോക്കുകളെ റീസെറ്റ് ചെയ്യുന്നു.

കസ്റ്റം മാച്ചറുകൾ നിർമ്മിക്കുന്നു: ജെസ്റ്റിന്റെ അസ്സേർഷനുകൾ വികസിപ്പിക്കുന്നു

ജെസ്റ്റ് `toBe`, `toEqual`, `toBeTruthy`, `toBeFalsy` പോലുള്ള നിരവധി ബിൽറ്റ്-ഇൻ മാച്ചറുകൾ നൽകുന്നു. എന്നിരുന്നാലും, സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനകളോ അല്ലെങ്കിൽ ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ലോജിക്കുകളോ കൈകാര്യം ചെയ്യുമ്പോൾ, അസ്സേർഷനുകൾ കൂടുതൽ വ്യക്തമായും സംക്ഷിപ്തമായും പ്രകടിപ്പിക്കാൻ കസ്റ്റം മാച്ചറുകൾ നിർമ്മിക്കേണ്ടതായി വരും. കസ്റ്റം മാച്ചറുകൾ കോഡിന്റെ വായനാക്ഷമത മെച്ചപ്പെടുത്തുകയും ആവർത്തനം കുറയ്ക്കുകയും ചെയ്യുന്നു, ഇത് നിങ്ങളുടെ ടെസ്റ്റുകൾ മനസ്സിലാക്കാനും പരിപാലിക്കാനും എളുപ്പമാക്കുന്നു.

ഒരു കസ്റ്റം മാച്ചർ നിർവചിക്കുന്നു

കസ്റ്റം മാച്ചറുകൾ, `received` വാല്യൂ (പരിശോധിക്കുന്ന മൂല്യം) സ്വീകരിച്ച്, രണ്ട് പ്രോപ്പർട്ടികളുള്ള ഒരു ഒബ്ജക്റ്റ് തിരികെ നൽകുന്ന ഫംഗ്ഷനുകളായി നിർവചിച്ചിരിക്കുന്നു: `pass` (അസ്സേർഷൻ പാസായോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ), `message` (അസ്സേർഷൻ എന്തുകൊണ്ട് പാസായി അല്ലെങ്കിൽ പരാജയപ്പെട്ടു എന്ന് വിശദീകരിക്കുന്ന ഒരു സന്ദേശം നൽകുന്ന ഒരു ഫംഗ്ഷൻ). ഒരു നമ്പർ ഒരു നിശ്ചിത പരിധിക്കുള്ളിലാണോ എന്ന് പരിശോധിക്കാൻ നമുക്കൊരു കസ്റ്റം മാച്ചർ ഉണ്ടാക്കാം.

ഉദാഹരണം (`src/setupTests.js`):

expect.extend({
  toBeWithinRange(received, floor, ceiling) {
    const pass = received >= floor && received <= ceiling;
    if (pass) {
      return {
        message: () =>
          `expected ${received} not to be within range ${floor} - ${ceiling}`,
        pass: true,
      };
    } else {
      return {
        message: () =>
          `expected ${received} to be within range ${floor} - ${ceiling}`,
        pass: false,
      };
    }
  },
});

ഈ ഉദാഹരണത്തിൽ, നമ്മൾ `toBeWithinRange` എന്നൊരു കസ്റ്റം മാച്ചർ നിർവചിക്കുന്നു, അത് മൂന്ന് ആർഗ്യുമെന്റുകൾ എടുക്കുന്നു: `received` വാല്യൂ (പരിശോധിക്കുന്ന നമ്പർ), `floor` (കുറഞ്ഞ മൂല്യം), `ceiling` (കൂടിയ മൂല്യം). `received` വാല്യൂ നിർദ്ദിഷ്ട പരിധിക്കുള്ളിലാണോ എന്ന് മാച്ചർ പരിശോധിക്കുകയും `pass`, `message` എന്നീ പ്രോപ്പർട്ടികളുള്ള ഒരു ഒബ്ജക്റ്റ് തിരികെ നൽകുകയും ചെയ്യുന്നു.

ഒരു കസ്റ്റം മാച്ചർ ഉപയോഗിക്കുന്നു

നിങ്ങൾ ഒരു കസ്റ്റം മാച്ചർ നിർവചിച്ചുകഴിഞ്ഞാൽ, മറ്റേതൊരു ബിൽറ്റ്-ഇൻ മാച്ചറെയും പോലെ നിങ്ങളുടെ ടെസ്റ്റുകളിൽ ഇത് ഉപയോഗിക്കാം.

ഉദാഹരണം (`src/myModule.test.js`):

import './setupTests'; // കസ്റ്റം മാച്ചറുകൾ ലോഡ് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക

describe('toBeWithinRange', () => {
  it('passes when the number is within the range', () => {
    expect(5).toBeWithinRange(1, 10);
  });

  it('fails when the number is outside the range', () => {
    expect(0).not.toBeWithinRange(1, 10);
  });
});

ഈ ടെസ്റ്റ് സ്യൂട്ട് `toBeWithinRange` എന്ന കസ്റ്റം മാച്ചർ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് കാണിക്കുന്നു. ആദ്യത്തെ ടെസ്റ്റ് കേസ് 5 എന്ന നമ്പർ 1-നും 10-നും ഇടയിലുള്ള പരിധിയിലാണെന്ന് ഉറപ്പിക്കുന്നു, രണ്ടാമത്തെ ടെസ്റ്റ് കേസ് 0 എന്ന നമ്പർ അതേ പരിധിയിലല്ലെന്നും ഉറപ്പിക്കുന്നു.

കൂടുതൽ സങ്കീർണ്ണമായ കസ്റ്റം മാച്ചറുകൾ നിർമ്മിക്കുന്നു

സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനകളോ ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ലോജിക്കുകളോ ടെസ്റ്റ് ചെയ്യാൻ കസ്റ്റം മാച്ചറുകൾ ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, കേസ് പരിഗണിക്കാതെ, ഒരു അറേയിൽ ഒരു പ്രത്യേക എലമെന്റ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കാൻ നമുക്കൊരു കസ്റ്റം മാച്ചർ ഉണ്ടാക്കാം.

ഉദാഹരണം (`src/setupTests.js`):

expect.extend({
  toContainIgnoreCase(received, expected) {
    const pass = received.some(
      (item) => item.toLowerCase() === expected.toLowerCase()
    );
    if (pass) {
      return {
        message: () =>
          `expected ${received} not to contain ${expected} (case-insensitive)`,
        pass: true,
      };
    } else {
      return {
        message: () =>
          `expected ${received} to contain ${expected} (case-insensitive)`,
        pass: false,
      };
    }
  },
});

ഈ മാച്ചർ `received` അറേയിലൂടെ കടന്നുപോകുകയും ഏതെങ്കിലും എലമെന്റുകൾ, ലോവർകേസിലേക്ക് മാറ്റുമ്പോൾ, `expected` വാല്യൂവുമായി (ലോവർകേസിലേക്ക് മാറ്റിയതിന് ശേഷം) പൊരുത്തപ്പെടുന്നുണ്ടോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു. ഇത് അറേകളിൽ കേസ്-ഇൻസെൻസിറ്റീവ് അസ്സേർഷനുകൾ നടത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഇന്റർനാഷണലൈസേഷൻ (i18n) ടെസ്റ്റിംഗിനായുള്ള കസ്റ്റം മാച്ചറുകൾ

അന്താരാഷ്ട്രവൽക്കരിച്ച ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുമ്പോൾ, വിവിധ ലൊക്കേലുകളിൽ ടെക്സ്റ്റ് വിവർത്തനങ്ങൾ ശരിയും സ്ഥിരതയുള്ളതുമാണെന്ന് പരിശോധിക്കേണ്ടത് അത്യാവശ്യമാണ്. ഈ ആവശ്യത്തിനായി കസ്റ്റം മാച്ചറുകൾ വളരെ വിലപ്പെട്ടതാണ്. ഉദാഹരണത്തിന്, ഒരു പ്രാദേശികവൽക്കരിച്ച സ്ട്രിംഗ് ഒരു പ്രത്യേക പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ അല്ലെങ്കിൽ ഒരു പ്രത്യേക ഭാഷയ്ക്കായി ഒരു പ്രത്യേക കീവേഡ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കാൻ നിങ്ങൾക്ക് ഒരു കസ്റ്റം മാച്ചർ നിർമ്മിക്കാൻ കഴിയും.

ഉദാഹരണം (`src/setupTests.js` - കീകൾ വിവർത്തനം ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾക്കുണ്ടെന്ന് ഈ ഉദാഹരണം അനുമാനിക്കുന്നു):

import { translate } from './i18n';

expect.extend({
  toHaveTranslation(received, key, locale) {
    const translatedString = translate(key, locale);
    const pass = received.includes(translatedString);

    if (pass) {
      return {
        message: () => `expected ${received} not to contain translation for key ${key} in locale ${locale}`,
        pass: true,
      };
    } else {
      return {
        message: () => `expected ${received} to contain translation for key ${key} in locale ${locale}`,
        pass: false,
      };
    }
  },
});

ഉദാഹരണം (`src/i18n.js` - അടിസ്ഥാന വിവർത്തന ഉദാഹരണം):

const translations = {
  en: {
    "welcome": "Welcome!"
  },
  fr: {
    "welcome": "Bienvenue!"
  }
}

export const translate = (key, locale) => {
  return translations[locale][key];
};

ഇനി നിങ്ങളുടെ ടെസ്റ്റിൽ (`src/myComponent.test.js`):

import './setupTests';

it('should display translated greeting in french', () => {
    const greeting = "Bienvenue!";
    expect(greeting).toHaveTranslation("welcome", "fr");
});

ഈ ഉദാഹരണം, `Bienvenue!` എന്നത് ഫ്രഞ്ചിൽ "welcome" എന്നതിന്റെ വിവർത്തനം ചെയ്ത മൂല്യമാണോ എന്ന് പരിശോധിക്കുന്നു. നിങ്ങളുടെ പ്രത്യേക ഇന്റർനാഷണലൈസേഷൻ ലൈബ്രറിക്കോ സമീപനത്തിനോ അനുയോജ്യമായ രീതിയിൽ `translate` ഫംഗ്ഷൻ ക്രമീകരിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക. ശരിയായ i18n ടെസ്റ്റിംഗ്, നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ വിവിധ സാംസ്കാരിക പശ്ചാത്തലങ്ങളിൽ നിന്നുള്ള ഉപയോക്താക്കളുമായി നല്ലരീതിയിൽ സംവദിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

കസ്റ്റം മാച്ചറുകളുടെ പ്രയോജനങ്ങൾ

• മെച്ചപ്പെട്ട വായനാക്ഷമത: കസ്റ്റം മാച്ചറുകൾ നിങ്ങളുടെ ടെസ്റ്റുകളെ കൂടുതൽ പ്രകടവും മനസ്സിലാക്കാൻ എളുപ്പമുള്ളതുമാക്കുന്നു, പ്രത്യേകിച്ചും സങ്കീർണ്ണമായ അസ്സേർഷനുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ.
• ആവർത്തനം കുറയ്ക്കുന്നു: കസ്റ്റം മാച്ചറുകൾ സാധാരണ അസ്സേർഷൻ ലോജിക് പുനരുപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് കോഡിന്റെ ആവർത്തനം കുറയ്ക്കുകയും പരിപാലനം മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.
• ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട അസ്സേർഷനുകൾ: നിങ്ങളുടെ ഡൊമെയ്‌നിന് മാത്രമായുള്ള അസ്സേർഷനുകൾ സൃഷ്ടിക്കാൻ കസ്റ്റം മാച്ചറുകൾ നിങ്ങളെ സഹായിക്കുന്നു, ഇത് നിങ്ങളുടെ ടെസ്റ്റുകളെ കൂടുതൽ പ്രസക്തവും അർത്ഥവത്തായതുമാക്കുന്നു.
• മെച്ചപ്പെട്ട സഹകരണം: കസ്റ്റം മാച്ചറുകൾ ടെസ്റ്റിംഗ് രീതികളിൽ സ്ഥിരത പ്രോത്സാഹിപ്പിക്കുന്നു, ഇത് ടീമുകൾക്ക് ടെസ്റ്റ് സ്യൂട്ടുകളിൽ സഹകരിക്കുന്നത് എളുപ്പമാക്കുന്നു.

ജെസ്റ്റ് കോൺഫിഗറേഷനും കസ്റ്റം മാച്ചറുകൾക്കുമുള്ള മികച്ച പരിശീലനങ്ങൾ

ജെസ്റ്റ് കോൺഫിഗറേഷന്റെയും കസ്റ്റം മാച്ചറുകളുടെയും കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്നതിന്, ഇനിപ്പറയുന്ന മികച്ച പരിശീലനങ്ങൾ പരിഗണിക്കുക:

• കോൺഫിഗറേഷൻ ലളിതമായി സൂക്ഷിക്കുക: അനാവശ്യമായ കോൺഫിഗറേഷൻ ഒഴിവാക്കുക. സാധ്യമാകുമ്പോഴെല്ലാം ജെസ്റ്റിന്റെ സീറോ-കോൺഫിഗറേഷൻ ഡിഫോൾട്ടുകൾ പ്രയോജനപ്പെടുത്തുക.
• ടെസ്റ്റ് ഫയലുകൾ ഓർഗനൈസ് ചെയ്യുക: ടെസ്റ്റ് ഫയലുകൾക്ക് സ്ഥിരമായ പേരിടൽ രീതി സ്വീകരിക്കുകയും അവയെ നിങ്ങളുടെ പ്രോജക്റ്റ് ഘടനയിൽ യുക്തിസഹമായി ക്രമീകരിക്കുകയും ചെയ്യുക.
• വ്യക്തവും സംക്ഷിപ്തവുമായ കസ്റ്റം മാച്ചറുകൾ എഴുതുക: നിങ്ങളുടെ കസ്റ്റം മാച്ചറുകൾ മനസ്സിലാക്കാനും പരിപാലിക്കാനും എളുപ്പമാണെന്ന് ഉറപ്പാക്കുക. ഒരു അസ്സേർഷൻ പരാജയപ്പെട്ടത് എന്തുകൊണ്ടാണെന്ന് വ്യക്തമായി വിശദീകരിക്കുന്ന സഹായകമായ പിശക് സന്ദേശങ്ങൾ നൽകുക.
• നിങ്ങളുടെ കസ്റ്റം മാച്ചറുകൾ ടെസ്റ്റ് ചെയ്യുക: നിങ്ങളുടെ കസ്റ്റം മാച്ചറുകൾ ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ അവയ്‌ക്കായി ടെസ്റ്റുകൾ എഴുതുക.
• നിങ്ങളുടെ കസ്റ്റം മാച്ചറുകൾ ഡോക്യുമെന്റ് ചെയ്യുക: നിങ്ങളുടെ കസ്റ്റം മാച്ചറുകൾക്ക് വ്യക്തമായ ഡോക്യുമെന്റേഷൻ നൽകുക, അതുവഴി മറ്റ് ഡെവലപ്പർമാർക്ക് അവ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് മനസ്സിലാക്കാൻ കഴിയും.
• ആഗോള കോഡിംഗ് മാനദണ്ഡങ്ങൾ പാലിക്കുക: എല്ലാ ടീം അംഗങ്ങൾക്കിടയിലും, അവരുടെ സ്ഥാനം പരിഗണിക്കാതെ, കോഡിന്റെ ഗുണനിലവാരവും പരിപാലനവും ഉറപ്പാക്കാൻ സ്ഥാപിതമായ കോഡിംഗ് മാനദണ്ഡങ്ങളും മികച്ച പരിശീലനങ്ങളും പാലിക്കുക.
• ടെസ്റ്റുകളിൽ പ്രാദേശികവൽക്കരണം പരിഗണിക്കുക: വിവിധ ഭാഷാ ക്രമീകരണങ്ങളിൽ നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ ശരിയായി സാധൂകരിക്കുന്നതിന് പ്രാദേശിക-നിർദ്ദിഷ്ട ടെസ്റ്റ് ഡാറ്റ ഉപയോഗിക്കുക അല്ലെങ്കിൽ i18n-നായി കസ്റ്റം മാച്ചറുകൾ സൃഷ്ടിക്കുക.

ഉപസംഹാരം: ജെസ്റ്റ് ഉപയോഗിച്ച് വിശ്വസനീയമായ ജാവാസ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നു

ജെസ്റ്റ് നിങ്ങളുടെ ജാവാസ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകളുടെ ഗുണമേന്മയും വിശ്വാസ്യതയും ഗണ്യമായി വർദ്ധിപ്പിക്കാൻ കഴിയുന്ന ശക്തവും വൈവിധ്യപൂർണ്ണവുമായ ഒരു ടെസ്റ്റിംഗ് ഫ്രെയിംവർക്കാണ്. ജെസ്റ്റ് കോൺഫിഗറേഷനിൽ പ്രാവീണ്യം നേടുന്നതിലൂടെയും കസ്റ്റം മാച്ചറുകൾ സൃഷ്ടിക്കുന്നതിലൂടെയും, നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ പ്രത്യേക ആവശ്യങ്ങൾക്കനുസരിച്ച് ടെസ്റ്റിംഗ് എൻവയോൺമെന്റ് ക്രമീകരിക്കാനും, കൂടുതൽ പ്രകടവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ ടെസ്റ്റുകൾ എഴുതാനും, നിങ്ങളുടെ കോഡ് വിവിധ എൻവയോൺമെന്റുകളിലും ഉപയോക്താക്കൾക്കിടയിലും പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാനും കഴിയും. നിങ്ങളൊരു ചെറിയ വെബ് ആപ്ലിക്കേഷനോ വലിയ തോതിലുള്ള എന്റർപ്രൈസ് സിസ്റ്റമോ നിർമ്മിക്കുകയാണെങ്കിലും, ആഗോള പ്രേക്ഷകർക്കായി കരുത്തുറ്റതും വിശ്വസനീയവുമായ സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കാൻ ആവശ്യമായ ഉപകരണങ്ങൾ ജെസ്റ്റ് നൽകുന്നു. ജെസ്റ്റിനെ സ്വീകരിച്ച് നിങ്ങളുടെ ജാവാസ്ക്രിപ്റ്റ് ടെസ്റ്റിംഗ് രീതികളെ പുതിയ ഉയരങ്ങളിലേക്ക് എത്തിക്കുക, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കളെ തൃപ്തിപ്പെടുത്താൻ ആവശ്യമായ നിലവാരം പുലർത്തുന്നുവെന്ന് ഉറപ്പുവരുത്തുക.